// 02_functions.rs
// Rust 函数教程

// 1. 基本函数定义
// 使用 fn 关键字定义函数
// 函数名使用 snake_case 命名规范
fn hello() {
    println!("Hello, world!");
}

// 2. 带参数的函数
// 参数必须声明类型
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

// 3. 带返回值的函数
// 返回值类型通过 -> 指定
// 函数体中最后一个表达式作为返回值（不带分号）
fn plus_one(x: i32) -> i32 {
    x + 1
}

// 4. 带多个参数和返回值的函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // 表达式，不带分号
}

// 5. 包含语句和表达式的函数
fn expression_example() -> i32 {
    let x = 3;
    let y = {
        let z = 5;
        z + 1  // 表达式，返回 6
    };
    x + y  // 返回 3 + 6 = 9
}

// 6. 不返回值的函数（返回单元类型 ()）
fn no_return() {
    println!("这个函数不返回值");
    // 隐式返回单元类型 ()
}

// 7. 使用 return 关键字提前返回
fn early_return(x: i32) -> i32 {
    if x < 0 {
        return 0;  // 提前返回
    }
    x * 2
}

fn main() {
    // 调用基本函数
    hello();
    
    // 调用带参数的函数
    greet("Rust");
    greet("学习者");
    
    // 调用带返回值的函数
    let result = plus_one(5);
    println!("5 + 1 = {}", result);
    
    // 调用多参数函数
    let sum = add(3, 7);
    println!("3 + 7 = {}", sum);
    
    // 表达式示例
    let expr_result = expression_example();
    println!("表达式结果: {}", expr_result);
    
    // 无返回值函数
    no_return();
    
    // 提前返回函数
    println!("early_return(5) = {}", early_return(5));
    println!("early_return(-3) = {}", early_return(-3));
    
    // 8. 函数参数作用域
    let outer_var = 10;
    scope_example(outer_var);
    println!("outer_var 在函数外部: {}", outer_var); // 这里仍然可以访问
}

// 9. 参数作用域示例
fn scope_example(param: i32) {
    println!("参数 param 的值: {}", param);
    let param = param * 2;  // 变量遮蔽
    println!("遮蔽后 param 的值: {}", param);
    // param 在函数结束时销毁
}